// Emacs style mode select	 -*- C++ -*-
//-----------------------------------------------------------------------------
//
// $Id:$
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This source is available for distribution and/or modification
// only under the terms of the DOOM Source Code License as
// published by id Software. All rights reserved.
//
// The source is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
// for more details.
//
// $Log:$
//
// DESCRIPTION:
//		Status bar code.
//		Does the face/direction indicator animatin.
//		Does palette indicators as well (red pain/berserk, bright pickup)
//
//-----------------------------------------------------------------------------

static const char
rcsid[] = "$Id: st_stuff.c,v 1.6 1997/02/03 22:45:13 b1 Exp $";


#include <stdio.h>

#include "i_system.h"
#include "i_video.h"
#include "z_zone.h"
#include "m_random.h"
#include "w_wad.h"

#include "doomdef.h"

#include "g_game.h"

#include "st_stuff.h"
#include "st_lib.h"
#include "r_local.h"

#include "p_local.h"
#include "p_inter.h"

#include "am_map.h"
#include "m_cheat.h"

#include "s_sound.h"

// Needs access to LFB.
#include "v_video.h"

// State.
#include "doomstat.h"

// Data.
#include "dstrings.h"
#include "sounds.h"

//
// STATUS BAR DATA
//


// Palette indices.
// For damage/bonus red-/gold-shifts
#define STARTREDPALS			1
#define STARTBONUSPALS			9
#define NUMREDPALS						8
#define NUMBONUSPALS			4
// Radiation suit, green shift.
#define RADIATIONPAL			13

// N/256*100% probability
//	that the normal face state will change
#define ST_FACEPROBABILITY				96

// For Responder
#define ST_TOGGLECHAT			KEY_ENTER

// Location of status bar
#define ST_X							0
#define ST_X2							104

#define ST_FX					143
#define ST_FY					169

// Should be set to patch width
//	for tall numbers later on
#define ST_TALLNUMWIDTH			(tallnum[0]->width)

// Number of status faces.
#define ST_NUMPAINFACES			5
#define ST_NUMSTRAIGHTFACES		3
#define ST_NUMTURNFACES			2
#define ST_NUMSPECIALFACES				3

#define ST_FACESTRIDE \
		  (ST_NUMSTRAIGHTFACES+ST_NUMTURNFACES+ST_NUMSPECIALFACES)

#define ST_NUMEXTRAFACES				2

#define ST_NUMFACES \
		  (ST_FACESTRIDE*ST_NUMPAINFACES+ST_NUMEXTRAFACES)

#define ST_TURNOFFSET			(ST_NUMSTRAIGHTFACES)
#define ST_OUCHOFFSET			(ST_TURNOFFSET + ST_NUMTURNFACES)
#define ST_EVILGRINOFFSET				(ST_OUCHOFFSET + 1)
#define ST_RAMPAGEOFFSET				(ST_EVILGRINOFFSET + 1)
#define ST_GODFACE						(ST_NUMPAINFACES*ST_FACESTRIDE)
#define ST_DEADFACE						(ST_GODFACE+1)

#define ST_FACESX						143
#define ST_FACESY						168

#define ST_EVILGRINCOUNT				(2*TICRATE)
#define ST_STRAIGHTFACECOUNT	(TICRATE/2)
#define ST_TURNCOUNT			(1*TICRATE)
#define ST_OUCHCOUNT			(1*TICRATE)
#define ST_RAMPAGEDELAY			(2*TICRATE)

#define ST_MUCHPAIN						20


// Location and size of statistics,
//	justified according to widget type.
// Problem is, within which space? STbar? Screen?
// Note: this could be read in by a lump.
//		 Problem is, is the stuff rendered
//		 into a buffer,
//		 or into the frame buffer?

// AMMO number pos.
#define ST_AMMOWIDTH			3
#define ST_AMMOX						44
#define ST_AMMOY						171

// HEALTH number pos.
#define ST_HEALTHWIDTH			3
#define ST_HEALTHX						90
#define ST_HEALTHY						171

// Weapon pos.
#define ST_ARMSX						111
#define ST_ARMSY						172
#define ST_ARMSBGX						104
#define ST_ARMSBGY						168
#define ST_ARMSXSPACE			12
#define ST_ARMSYSPACE			10

// Frags pos.
#define ST_FRAGSX						138
#define ST_FRAGSY						171
#define ST_FRAGSWIDTH			2

// ARMOR number pos.
#define ST_ARMORWIDTH			3
#define ST_ARMORX						221
#define ST_ARMORY						171

// Key icon positions.
#define ST_KEY0WIDTH			8
#define ST_KEY0HEIGHT			5
#define ST_KEY0X						239
#define ST_KEY0Y						171
#define ST_KEY1WIDTH			ST_KEY0WIDTH
#define ST_KEY1X						239
#define ST_KEY1Y						181
#define ST_KEY2WIDTH			ST_KEY0WIDTH
#define ST_KEY2X						239
#define ST_KEY2Y						191

// Ammunition counter.
#define ST_AMMO0WIDTH			3
#define ST_AMMO0HEIGHT			6
#define ST_AMMO0X						288
#define ST_AMMO0Y						173
#define ST_AMMO1WIDTH			ST_AMMO0WIDTH
#define ST_AMMO1X						288
#define ST_AMMO1Y						179
#define ST_AMMO2WIDTH			ST_AMMO0WIDTH
#define ST_AMMO2X						288
#define ST_AMMO2Y						191
#define ST_AMMO3WIDTH			ST_AMMO0WIDTH
#define ST_AMMO3X						288
#define ST_AMMO3Y						185

// Indicate maximum ammunition.
// Only needed because backpack exists.
#define ST_MAXAMMO0WIDTH				3
#define ST_MAXAMMO0HEIGHT				5
#define ST_MAXAMMO0X			314
#define ST_MAXAMMO0Y			173
#define ST_MAXAMMO1WIDTH				ST_MAXAMMO0WIDTH
#define ST_MAXAMMO1X			314
#define ST_MAXAMMO1Y			179
#define ST_MAXAMMO2WIDTH				ST_MAXAMMO0WIDTH
#define ST_MAXAMMO2X			314
#define ST_MAXAMMO2Y			191
#define ST_MAXAMMO3WIDTH				ST_MAXAMMO0WIDTH
#define ST_MAXAMMO3X			314
#define ST_MAXAMMO3Y			185

// pistol
#define ST_WEAPON0X						110
#define ST_WEAPON0Y						172

// shotgun
#define ST_WEAPON1X						122
#define ST_WEAPON1Y						172

// chain gun
#define ST_WEAPON2X						134
#define ST_WEAPON2Y						172

// missile launcher
#define ST_WEAPON3X						110
#define ST_WEAPON3Y						181

// plasma gun
#define ST_WEAPON4X						122
#define ST_WEAPON4Y						181

// bfg
#define ST_WEAPON5X						134
#define ST_WEAPON5Y						181

// WPNS title
#define ST_WPNSX						109
#define ST_WPNSY						191

// DETH title
#define ST_DETHX						109
#define ST_DETHY						191

//Incoming messages window location
//UNUSED
// #define ST_MSGTEXTX	   (viewwindowx)
// #define ST_MSGTEXTY	   (viewwindowy+viewheight-18)
#define ST_MSGTEXTX						0
#define ST_MSGTEXTY						0
// Dimensions given in characters.
#define ST_MSGWIDTH						52
// Or shall I say, in lines?
#define ST_MSGHEIGHT			1

#define ST_OUTTEXTX						0
#define ST_OUTTEXTY						6

// Width, in characters again.
#define ST_OUTWIDTH						52
// Height, in lines.
#define ST_OUTHEIGHT			1

#define ST_MAPWIDTH		\
	(strlen(mapnames[(gameepisode-1)*9+(gamemap-1)]))

#define ST_MAPTITLEX \
	(SCREENWIDTH - ST_MAPWIDTH * ST_CHATFONTWIDTH)

#define ST_MAPTITLEY			0
#define ST_MAPHEIGHT			1


// main player in game
static player_t*		plyr;

// ST_Start() has just been called
static boolean			st_firsttime;

// used to execute ST_Init() only once
static int				veryfirsttime = 1;

// lump number for PLAYPAL
static int				lu_palette;

// used for timing
static unsigned int		st_clock;

// used for making messages go away
static int				st_msgcounter=0;

// used when in chat
static st_chatstateenum_t		st_chatstate;

// whether in automap or first-person
static st_stateenum_t	st_gamestate;

// whether left-side main status bar is active
static boolean			st_statusbaron;

// whether status bar chat is active
static boolean			st_chat;

// value of st_chat before message popped up
static boolean			st_oldchat;

// whether chat window has the cursor on
static boolean			st_cursoron;

// !deathmatch
static boolean			st_notdeathmatch;

// !deathmatch && st_statusbaron
static boolean			st_armson;

// !deathmatch
static boolean			st_fragson;

// main bar left
static patch_t*			sbar;

// 0-9, tall numbers
static patch_t*			tallnum[10];

// tall % sign
static patch_t*			tallpercent;

// 0-9, short, yellow (,different!) numbers
static patch_t*			shortnum[10];

// 3 key-cards, 3 skulls
static patch_t*			keys[NUMCARDS];

// face status patches
static patch_t*			faces[ST_NUMFACES];

// face background
static patch_t*			faceback;

// main bar right
static patch_t*			armsbg;

// weapon ownership patches
static patch_t*			arms[6][2];

// ready-weapon widget
static st_number_t		w_ready;

// in deathmatch only, summary of frags stats
static st_number_t		w_frags;

// health widget
static st_percent_t		w_health;

// arms background
static st_binicon_t		w_armsbg;


// weapon ownership widgets
static st_multicon_t	w_arms[6];

// face status widget
static st_multicon_t	w_faces;

// keycard widgets
static st_multicon_t	w_keyboxes[3];

// armor widget
static st_percent_t		w_armor;

// ammo widgets
static st_number_t		w_ammo[4];

// max ammo widgets
static st_number_t		w_maxammo[4];



// number of frags so far in deathmatch
static int		st_fragscount;

// used to use appopriately pained face
static int		st_oldhealth = -1;

// used for evil grin
static boolean	oldweaponsowned[NUMWEAPONS];

// count until face changes
static int		st_facecount = 0;

// current face index, used by w_faces
static int		st_faceindex = 0;

// holds key-type for each key box on bar
static int		keyboxes[3];

// a random number per tick
static int		st_randomnumber;



// Massive bunches of cheat shit
//	to keep it from being easy to figure them out.
// Yeah, right...
unsigned char	cheat_mus_seq[] =
{
    0xb2, 0x26, 0xb6, 0xae, 0xea, 1, 0, 0, 0xff
};

unsigned char	cheat_choppers_seq[] =
{
    0xb2, 0x26, 0xe2, 0x32, 0xf6, 0x2a, 0x2a, 0xa6, 0x6a, 0xea, 0xff // id...
};

unsigned char	cheat_god_seq[] =
{
    0xb2, 0x26, 0x26, 0xaa, 0x26, 0xff	// iddqd
};

unsigned char	cheat_ammo_seq[] =
{
    0xb2, 0x26, 0xf2, 0x66, 0xa2, 0xff	// idkfa
};

unsigned char	cheat_ammonokey_seq[] =
{
    0xb2, 0x26, 0x66, 0xa2, 0xff		// idfa
};


// Smashing Pumpkins Into Samml Piles Of Putried Debris.
unsigned char	cheat_noclip_seq[] =
{
    0xb2, 0x26, 0xea, 0x2a, 0xb2,		// idspispopd
    0xea, 0x2a, 0xf6, 0x2a, 0x26, 0xff
};

//
unsigned char	cheat_commercial_noclip_seq[] =
{
    0xb2, 0x26, 0xe2, 0x36, 0xb2, 0x2a, 0xff	// idclip
};



unsigned char	cheat_powerup_seq[7][10] =
{
    { 0xb2, 0x26, 0x62, 0xa6, 0x32, 0xf6, 0x36, 0x26, 0x6e, 0xff },		// beholdv
    { 0xb2, 0x26, 0x62, 0xa6, 0x32, 0xf6, 0x36, 0x26, 0xea, 0xff },		// beholds
    { 0xb2, 0x26, 0x62, 0xa6, 0x32, 0xf6, 0x36, 0x26, 0xb2, 0xff },		// beholdi
    { 0xb2, 0x26, 0x62, 0xa6, 0x32, 0xf6, 0x36, 0x26, 0x6a, 0xff },		// beholdr
    { 0xb2, 0x26, 0x62, 0xa6, 0x32, 0xf6, 0x36, 0x26, 0xa2, 0xff },		// beholda
    { 0xb2, 0x26, 0x62, 0xa6, 0x32, 0xf6, 0x36, 0x26, 0x36, 0xff },		// beholdl
    { 0xb2, 0x26, 0x62, 0xa6, 0x32, 0xf6, 0x36, 0x26, 0xff }			// behold
};


unsigned char	cheat_clev_seq[] =
{
    0xb2, 0x26,	 0xe2, 0x36, 0xa6, 0x6e, 1, 0, 0, 0xff	// idclev
};


// my position cheat
unsigned char	cheat_mypos_seq[] =
{
    0xb2, 0x26, 0xb6, 0xba, 0x2a, 0xf6, 0xea, 0xff		// idmypos
};


// Now what?
cheatseq_t		cheat_mus = { cheat_mus_seq, 0 };
cheatseq_t		cheat_god = { cheat_god_seq, 0 };
cheatseq_t		cheat_ammo = { cheat_ammo_seq, 0 };
cheatseq_t		cheat_ammonokey = { cheat_ammonokey_seq, 0 };
cheatseq_t		cheat_noclip = { cheat_noclip_seq, 0 };
cheatseq_t		cheat_commercial_noclip = { cheat_commercial_noclip_seq, 0 };

cheatseq_t		cheat_powerup[7] =
{
    { cheat_powerup_seq[0], 0 },
    { cheat_powerup_seq[1], 0 },
    { cheat_powerup_seq[2], 0 },
    { cheat_powerup_seq[3], 0 },
    { cheat_powerup_seq[4], 0 },
    { cheat_powerup_seq[5], 0 },
    { cheat_powerup_seq[6], 0 }
};

cheatseq_t		cheat_choppers = { cheat_choppers_seq, 0 };
cheatseq_t		cheat_clev = { cheat_clev_seq, 0 };
cheatseq_t		cheat_mypos = { cheat_mypos_seq, 0 };


//
extern char*	mapnames[];


//
// STATUS BAR CODE
//
void ST_Stop(void);

void ST_refreshBackground(void)
{

    if (st_statusbaron)
    {
        V_DrawPatch(ST_X, 0, BG, sbar);

        if (netgame)
            V_DrawPatch(ST_FX, 0, BG, faceback);

        V_CopyRect(ST_X, 0, BG, ST_WIDTH, ST_HEIGHT, ST_X, ST_Y, FG);
    }

}


// Respond to keyboard input events,
//	intercept cheats.
boolean
ST_Responder (event_t* ev)
{
    int			i;

    // Filter automap on/off.
    if (ev->type == ev_keyup
            && ((ev->data1 & 0xffff0000) == AM_MSGHEADER))
    {
        switch(ev->data1)
        {
            case AM_MSGENTERED:
                st_gamestate = AutomapState;
                st_firsttime = true;
                break;

            case AM_MSGEXITED:
                //		fprintf(stderr, "AM exited\n");
                st_gamestate = FirstPersonState;
                break;
        }
    }

    // if a user keypress...
    else if (ev->type == ev_keydown)
    {
        if (!netgame)
        {
            // b. - enabled for more debug fun.
            // if (gameskill != sk_nightmare) {

            // 'dqd' cheat for toggleable god mode
            if (cht_CheckCheat(&cheat_god, ev->data1))
            {
                plyr->cheats ^= CF_GODMODE;
                if (plyr->cheats & CF_GODMODE)
                {
                    if (plyr->mo)
                        plyr->mo->health = 100;

                    plyr->health = 100;
                    plyr->message = STSTR_DQDON;
                }
                else
                    plyr->message = STSTR_DQDOFF;
            }
            // 'fa' cheat for killer fucking arsenal
            else if (cht_CheckCheat(&cheat_ammonokey, ev->data1))
            {
                plyr->armorpoints = 200;
                plyr->armortype = 2;

                for (i=0; i<NUMWEAPONS; i++)
                    plyr->weaponowned[i] = true;

                for (i=0; i<NUMAMMO; i++)
                    plyr->ammo[i] = plyr->maxammo[i];

                plyr->message = STSTR_FAADDED;
            }
            // 'kfa' cheat for key full ammo
            else if (cht_CheckCheat(&cheat_ammo, ev->data1))
            {
                plyr->armorpoints = 200;
                plyr->armortype = 2;

                for (i=0; i<NUMWEAPONS; i++)
                    plyr->weaponowned[i] = true;

                for (i=0; i<NUMAMMO; i++)
                    plyr->ammo[i] = plyr->maxammo[i];

                for (i=0; i<NUMCARDS; i++)
                    plyr->cards[i] = true;

                plyr->message = STSTR_KFAADDED;
            }
            // 'mus' cheat for changing music
            else if (cht_CheckCheat(&cheat_mus, ev->data1))
            {

                char	buf[3];
                int				musnum;

                plyr->message = STSTR_MUS;
                cht_GetParam(&cheat_mus, buf);

                if (gamemode == commercial)
                {
                    musnum = mus_runnin + (buf[0]-'0')*10 + buf[1]-'0' - 1;

                    if (((buf[0]-'0')*10 + buf[1]-'0') > 35)
                        plyr->message = STSTR_NOMUS;
                    else
                        S_ChangeMusic(musnum, 1);
                }
                else
                {
                    musnum = mus_e1m1 + (buf[0]-'1')*9 + (buf[1]-'1');

                    if (((buf[0]-'1')*9 + buf[1]-'1') > 31)
                        plyr->message = STSTR_NOMUS;
                    else
                        S_ChangeMusic(musnum, 1);
                }
            }
            // Simplified, accepting both "noclip" and "idspispopd".
            // no clipping mode cheat
            else if ( cht_CheckCheat(&cheat_noclip, ev->data1)
                      || cht_CheckCheat(&cheat_commercial_noclip,ev->data1) )
            {
                plyr->cheats ^= CF_NOCLIP;

                if (plyr->cheats & CF_NOCLIP)
                    plyr->message = STSTR_NCON;
                else
                    plyr->message = STSTR_NCOFF;
            }
            // 'behold?' power-up cheats
            for (i=0; i<6; i++)
            {
                if (cht_CheckCheat(&cheat_powerup[i], ev->data1))
                {
                    if (!plyr->powers[i])
                        P_GivePower( plyr, i);
                    else if (i!=pw_strength)
                        plyr->powers[i] = 1;
                    else
                        plyr->powers[i] = 0;

                    plyr->message = STSTR_BEHOLDX;
                }
            }

            // 'behold' power-up menu
            if (cht_CheckCheat(&cheat_powerup[6], ev->data1))
            {
                plyr->message = STSTR_BEHOLD;
            }
            // 'choppers' invulnerability & chainsaw
            else if (cht_CheckCheat(&cheat_choppers, ev->data1))
            {
                plyr->weaponowned[wp_chainsaw] = true;
                plyr->powers[pw_invulnerability] = true;
                plyr->message = STSTR_CHOPPERS;
            }
            // 'mypos' for player position
            else if (cht_CheckCheat(&cheat_mypos, ev->data1))
            {
                static char		buf[ST_MSGWIDTH];
                sprintf(buf, "ang=0x%x;x,y=(0x%x,0x%x)",
                        players[consoleplayer].mo->angle,
                        players[consoleplayer].mo->x,
                        players[consoleplayer].mo->y);
                plyr->message = buf;
            }
        }

        // 'clev' change-level cheat
        if (cht_CheckCheat(&cheat_clev, ev->data1))
        {
            char				buf[3];
            int				epsd;
            int				map;

            cht_GetParam(&cheat_clev, buf);

            if (gamemode == commercial)
            {
                epsd = 0;
                map = (buf[0] - '0')*10 + buf[1] - '0';
            }
            else
            {
                epsd = buf[0] - '0';
                map = buf[1] - '0';
            }

            // Catch invalid maps.
            if (epsd < 1)
                return false;

            if (map < 1)
                return false;

            // Ohmygod - this is not going to work.
            if ((gamemode == retail)
                    && ((epsd > 4) || (map > 9)))
                return false;

            if ((gamemode == registered)
                    && ((epsd > 3) || (map > 9)))
                return false;

            if ((gamemode == shareware)
                    && ((epsd > 1) || (map > 9)))
                return false;

            if ((gamemode == commercial)
                    && (( epsd > 1) || (map > 34)))
                return false;

            // So be it.
            plyr->message = STSTR_CLEV;
            G_DeferedInitNew(gameskill, epsd, map);
        }
    }
    return false;
}



int ST_calcPainOffset(void)
{
    int			health;
    static int	lastcalc;
    static int	oldhealth = -1;

    health = plyr->health > 100 ? 100 : plyr->health;

    if (health != oldhealth)
    {
        lastcalc = ST_FACESTRIDE * (((100 - health) * ST_NUMPAINFACES) / 101);
        oldhealth = health;
    }
    return lastcalc;
}


//
// This is a not-very-pretty routine which handles
//	the face states and their timing.
// the precedence of expressions is:
//	dead > evil grin > turned head > straight ahead
//
void ST_updateFaceWidget(void)
{
    int			i;
    angle_t		badguyangle;
    angle_t		diffang;
    static int	lastattackdown = -1;
    static int	priority = 0;
    boolean		doevilgrin;

    if (priority < 10)
    {
        // dead
        if (!plyr->health)
        {
            priority = 9;
            st_faceindex = ST_DEADFACE;
            st_facecount = 1;
        }
    }

    if (priority < 9)
    {
        if (plyr->bonuscount)
        {
            // picking up bonus
            doevilgrin = false;

            for (i=0; i<NUMWEAPONS; i++)
            {
                if (oldweaponsowned[i] != plyr->weaponowned[i])
                {
                    doevilgrin = true;
                    oldweaponsowned[i] = plyr->weaponowned[i];
                }
            }
            if (doevilgrin)
            {
                // evil grin if just picked up weapon
                priority = 8;
                st_facecount = ST_EVILGRINCOUNT;
                st_faceindex = ST_calcPainOffset() + ST_EVILGRINOFFSET;
            }
        }

    }

    if (priority < 8)
    {
        if (plyr->damagecount
                && plyr->attacker
                && plyr->attacker != plyr->mo)
        {
            // being attacked
            priority = 7;

            if (plyr->health - st_oldhealth > ST_MUCHPAIN)
            {
                st_facecount = ST_TURNCOUNT;
                st_faceindex = ST_calcPainOffset() + ST_OUCHOFFSET;
            }
            else
            {
                badguyangle = R_PointToAngle2(plyr->mo->x,
                                              plyr->mo->y,
                                              plyr->attacker->x,
                                              plyr->attacker->y);

                if (badguyangle > plyr->mo->angle)
                {
                    // whether right or left
                    diffang = badguyangle - plyr->mo->angle;
                    i = diffang > ANG180;
                }
                else
                {
                    // whether left or right
                    diffang = plyr->mo->angle - badguyangle;
                    i = diffang <= ANG180;
                } // confusing, aint it?


                st_facecount = ST_TURNCOUNT;
                st_faceindex = ST_calcPainOffset();

                if (diffang < ANG45)
                {
                    // head-on
                    st_faceindex += ST_RAMPAGEOFFSET;
                }
                else if (i)
                {
                    // turn face right
                    st_faceindex += ST_TURNOFFSET;
                }
                else
                {
                    // turn face left
                    st_faceindex += ST_TURNOFFSET+1;
                }
            }
        }
    }

    if (priority < 7)
    {
        // getting hurt because of your own damn stupidity
        if (plyr->damagecount)
        {
            if (plyr->health - st_oldhealth > ST_MUCHPAIN)
            {
                priority = 7;
                st_facecount = ST_TURNCOUNT;
                st_faceindex = ST_calcPainOffset() + ST_OUCHOFFSET;
            }
            else
            {
                priority = 6;
                st_facecount = ST_TURNCOUNT;
                st_faceindex = ST_calcPainOffset() + ST_RAMPAGEOFFSET;
            }

        }

    }

    if (priority < 6)
    {
        // rapid firing
        if (plyr->attackdown)
        {
            if (lastattackdown==-1)
                lastattackdown = ST_RAMPAGEDELAY;
            else if (!--lastattackdown)
            {
                priority = 5;
                st_faceindex = ST_calcPainOffset() + ST_RAMPAGEOFFSET;
                st_facecount = 1;
                lastattackdown = 1;
            }
        }
        else
            lastattackdown = -1;

    }

    if (priority < 5)
    {
        // invulnerability
        if ((plyr->cheats & CF_GODMODE)
                || plyr->powers[pw_invulnerability])
        {
            priority = 4;

            st_faceindex = ST_GODFACE;
            st_facecount = 1;

        }

    }

    // look left or look right if the facecount has timed out
    if (!st_facecount)
    {
        st_faceindex = ST_calcPainOffset() + (st_randomnumber % 3);
        st_facecount = ST_STRAIGHTFACECOUNT;
        priority = 0;
    }

    st_facecount--;

}

void ST_updateWidgets(void)
{
    static int	largeammo = 1994; // means "n/a"
    int			i;

    // must redirect the pointer if the ready weapon has changed.
    //	if (w_ready.data != plyr->readyweapon)
    //	{
    if (weaponinfo[plyr->readyweapon].ammo == am_noammo)
        w_ready.num = &largeammo;
    else
        w_ready.num = &plyr->ammo[weaponinfo[plyr->readyweapon].ammo];
    //{
    // static int tic=0;
    // static int dir=-1;
    // if (!(tic&15))
    //	 plyr->ammo[weaponinfo[plyr->readyweapon].ammo]+=dir;
    // if (plyr->ammo[weaponinfo[plyr->readyweapon].ammo] == -100)
    //	 dir = 1;
    // tic++;
    // }
    w_ready.data = plyr->readyweapon;

    // if (*w_ready.on)
    //	STlib_updateNum(&w_ready, true);
    // refresh weapon change
    //	}

    // update keycard multiple widgets
    for (i=0; i<3; i++)
    {
        keyboxes[i] = plyr->cards[i] ? i : -1;

        if (plyr->cards[i+3])
            keyboxes[i] = i+3;
    }

    // refresh everything if this is him coming back to life
    ST_updateFaceWidget();

    // used by the w_armsbg widget
    st_notdeathmatch = !deathmatch;

    // used by w_arms[] widgets
    st_armson = st_statusbaron && !deathmatch;

    // used by w_frags widget
    st_fragson = deathmatch && st_statusbaron;
    st_fragscount = 0;

    for (i=0 ; i<MAXPLAYERS ; i++)
    {
        if (i != consoleplayer)
            st_fragscount += plyr->frags[i];
        else
            st_fragscount -= plyr->frags[i];
    }

    // get rid of chat window if up because of message
    if (!--st_msgcounter)
        st_chat = st_oldchat;

}

void ST_Ticker (void)
{

    st_clock++;
    st_randomnumber = M_Random();
    ST_updateWidgets();
    st_oldhealth = plyr->health;

}

static int st_palette = 0;

void ST_doPaletteStuff(void)
{

    int			palette;
    byte*		pal;
    int			cnt;
    int			bzc;

    cnt = plyr->damagecount;

    if (plyr->powers[pw_strength])
    {
        // slowly fade the berzerk out
        bzc = 12 - (plyr->powers[pw_strength]>>6);

        if (bzc > cnt)
            cnt = bzc;
    }

    if (cnt)
    {
        palette = (cnt+7)>>3;

        if (palette >= NUMREDPALS)
            palette = NUMREDPALS-1;

        palette += STARTREDPALS;
    }

    else if (plyr->bonuscount)
    {
        palette = (plyr->bonuscount+7)>>3;

        if (palette >= NUMBONUSPALS)
            palette = NUMBONUSPALS-1;

        palette += STARTBONUSPALS;
    }

    else if ( plyr->powers[pw_ironfeet] > 4*32
              || plyr->powers[pw_ironfeet]&8)
        palette = RADIATIONPAL;
    else
        palette = 0;

    if (palette != st_palette)
    {
        st_palette = palette;
        pal = (byte *) W_CacheLumpNum (lu_palette, PU_CACHE)+palette*768;
        I_SetPalette (pal);
    }

}

void ST_drawWidgets(boolean refresh)
{
    int			i;

    // used by w_arms[] widgets
    st_armson = st_statusbaron && !deathmatch;

    // used by w_frags widget
    st_fragson = deathmatch && st_statusbaron;

    STlib_updateNum(&w_ready, refresh);

    for (i=0; i<4; i++)
    {
        STlib_updateNum(&w_ammo[i], refresh);
        STlib_updateNum(&w_maxammo[i], refresh);
    }

    STlib_updatePercent(&w_health, refresh);
    STlib_updatePercent(&w_armor, refresh);

    STlib_updateBinIcon(&w_armsbg, refresh);

    for (i=0; i<6; i++)
        STlib_updateMultIcon(&w_arms[i], refresh);

    STlib_updateMultIcon(&w_faces, refresh);

    for (i=0; i<3; i++)
        STlib_updateMultIcon(&w_keyboxes[i], refresh);

    STlib_updateNum(&w_frags, refresh);

}

void ST_doRefresh(void)
{

    st_firsttime = false;

    // draw status bar background to off-screen buff
    ST_refreshBackground();

    // and refresh all widgets
    ST_drawWidgets(true);

}

void ST_diffDraw(void)
{
    // update all widgets
    ST_drawWidgets(false);
}

void ST_Drawer (boolean fullscreen, boolean refresh)
{

    st_statusbaron = (!fullscreen) || automapactive;
    st_firsttime = st_firsttime || refresh;

    // Do red-/gold-shifts from damage/items
    ST_doPaletteStuff();

    // If just after ST_Start(), refresh all
    if (st_firsttime) ST_doRefresh();
    // Otherwise, update as little as possible
    else ST_diffDraw();

}

void ST_loadGraphics(void)
{

    int			i;
    int			j;
    int			facenum;

    char		namebuf[9];

    // Load the numbers, tall and short
    for (i=0; i<10; i++)
    {
        sprintf(namebuf, "STTNUM%d", i);
        tallnum[i] = (patch_t *) W_CacheLumpName(namebuf, PU_STATIC);

        sprintf(namebuf, "STYSNUM%d", i);
        shortnum[i] = (patch_t *) W_CacheLumpName(namebuf, PU_STATIC);
    }

    // Load percent key.
    //Note: why not load STMINUS here, too?
    tallpercent = (patch_t *) W_CacheLumpName("STTPRCNT", PU_STATIC);

    // key cards
    for (i=0; i<NUMCARDS; i++)
    {
        sprintf(namebuf, "STKEYS%d", i);
        keys[i] = (patch_t *) W_CacheLumpName(namebuf, PU_STATIC);
    }

    // arms background
    armsbg = (patch_t *) W_CacheLumpName("STARMS", PU_STATIC);

    // arms ownership widgets
    for (i=0; i<6; i++)
    {
        sprintf(namebuf, "STGNUM%d", i+2);

        // gray #
        arms[i][0] = (patch_t *) W_CacheLumpName(namebuf, PU_STATIC);

        // yellow #
        arms[i][1] = shortnum[i+2];
    }

    // face backgrounds for different color players
    sprintf(namebuf, "STFB%d", consoleplayer);
    faceback = (patch_t *) W_CacheLumpName(namebuf, PU_STATIC);

    // status bar background bits
    sbar = (patch_t *) W_CacheLumpName("STBAR", PU_STATIC);

    // face states
    facenum = 0;
    for (i=0; i<ST_NUMPAINFACES; i++)
    {
        for (j=0; j<ST_NUMSTRAIGHTFACES; j++)
        {
            sprintf(namebuf, "STFST%d%d", i, j);
            faces[facenum++] = W_CacheLumpName(namebuf, PU_STATIC);
        }
        sprintf(namebuf, "STFTR%d0", i);		// turn right
        faces[facenum++] = W_CacheLumpName(namebuf, PU_STATIC);
        sprintf(namebuf, "STFTL%d0", i);		// turn left
        faces[facenum++] = W_CacheLumpName(namebuf, PU_STATIC);
        sprintf(namebuf, "STFOUCH%d", i);		// ouch!
        faces[facenum++] = W_CacheLumpName(namebuf, PU_STATIC);
        sprintf(namebuf, "STFEVL%d", i);		// evil grin ;)
        faces[facenum++] = W_CacheLumpName(namebuf, PU_STATIC);
        sprintf(namebuf, "STFKILL%d", i);		// pissed off
        faces[facenum++] = W_CacheLumpName(namebuf, PU_STATIC);
    }
    faces[facenum++] = W_CacheLumpName("STFGOD0", PU_STATIC);
    faces[facenum++] = W_CacheLumpName("STFDEAD0", PU_STATIC);

}

void ST_loadData(void)
{
    lu_palette = W_GetNumForName ("PLAYPAL");
    ST_loadGraphics();
}

void ST_unloadGraphics(void)
{

    int i;

    // unload the numbers, tall and short
    for (i=0; i<10; i++)
    {
        Z_ChangeTag(tallnum[i], PU_CACHE);
        Z_ChangeTag(shortnum[i], PU_CACHE);
    }
    // unload tall percent
    Z_ChangeTag(tallpercent, PU_CACHE);

    // unload arms background
    Z_ChangeTag(armsbg, PU_CACHE);

    // unload gray #'s
    for (i=0; i<6; i++)
        Z_ChangeTag(arms[i][0], PU_CACHE);

    // unload the key cards
    for (i=0; i<NUMCARDS; i++)
        Z_ChangeTag(keys[i], PU_CACHE);

    Z_ChangeTag(sbar, PU_CACHE);
    Z_ChangeTag(faceback, PU_CACHE);

    for (i=0; i<ST_NUMFACES; i++)
        Z_ChangeTag(faces[i], PU_CACHE);

    // Note: nobody ain't seen no unloading
    //	 of stminus yet. Dude.


}

void ST_unloadData(void)
{
    ST_unloadGraphics();
}

void ST_initData(void)
{

    int			i;

    st_firsttime = true;
    plyr = &players[consoleplayer];

    st_clock = 0;
    st_chatstate = StartChatState;
    st_gamestate = FirstPersonState;

    st_statusbaron = true;
    st_oldchat = st_chat = false;
    st_cursoron = false;

    st_faceindex = 0;
    st_palette = -1;

    st_oldhealth = -1;

    for (i=0; i<NUMWEAPONS; i++)
        oldweaponsowned[i] = plyr->weaponowned[i];

    for (i=0; i<3; i++)
        keyboxes[i] = -1;

    STlib_init();

}



void ST_createWidgets(void)
{

    int i;

    // ready weapon ammo
    STlib_initNum(&w_ready,
                  ST_AMMOX,
                  ST_AMMOY,
                  tallnum,
                  &plyr->ammo[weaponinfo[plyr->readyweapon].ammo],
                  &st_statusbaron,
                  ST_AMMOWIDTH );

    // the last weapon type
    w_ready.data = plyr->readyweapon;

    // health percentage
    STlib_initPercent(&w_health,
                      ST_HEALTHX,
                      ST_HEALTHY,
                      tallnum,
                      &plyr->health,
                      &st_statusbaron,
                      tallpercent);

    // arms background
    STlib_initBinIcon(&w_armsbg,
                      ST_ARMSBGX,
                      ST_ARMSBGY,
                      armsbg,
                      &st_notdeathmatch,
                      &st_statusbaron);

    // weapons owned
    for(i=0; i<6; i++)
    {
        STlib_initMultIcon(&w_arms[i],
                           ST_ARMSX+(i%3)*ST_ARMSXSPACE,
                           ST_ARMSY+(i/3)*ST_ARMSYSPACE,
                           arms[i], (int *) &plyr->weaponowned[i+1],
                           &st_armson);
    }

    // frags sum
    STlib_initNum(&w_frags,
                  ST_FRAGSX,
                  ST_FRAGSY,
                  tallnum,
                  &st_fragscount,
                  &st_fragson,
                  ST_FRAGSWIDTH);

    // faces
    STlib_initMultIcon(&w_faces,
                       ST_FACESX,
                       ST_FACESY,
                       faces,
                       &st_faceindex,
                       &st_statusbaron);

    // armor percentage - should be colored later
    STlib_initPercent(&w_armor,
                      ST_ARMORX,
                      ST_ARMORY,
                      tallnum,
                      &plyr->armorpoints,
                      &st_statusbaron, tallpercent);

    // keyboxes 0-2
    STlib_initMultIcon(&w_keyboxes[0],
                       ST_KEY0X,
                       ST_KEY0Y,
                       keys,
                       &keyboxes[0],
                       &st_statusbaron);

    STlib_initMultIcon(&w_keyboxes[1],
                       ST_KEY1X,
                       ST_KEY1Y,
                       keys,
                       &keyboxes[1],
                       &st_statusbaron);

    STlib_initMultIcon(&w_keyboxes[2],
                       ST_KEY2X,
                       ST_KEY2Y,
                       keys,
                       &keyboxes[2],
                       &st_statusbaron);

    // ammo count (all four kinds)
    STlib_initNum(&w_ammo[0],
                  ST_AMMO0X,
                  ST_AMMO0Y,
                  shortnum,
                  &plyr->ammo[0],
                  &st_statusbaron,
                  ST_AMMO0WIDTH);

    STlib_initNum(&w_ammo[1],
                  ST_AMMO1X,
                  ST_AMMO1Y,
                  shortnum,
                  &plyr->ammo[1],
                  &st_statusbaron,
                  ST_AMMO1WIDTH);

    STlib_initNum(&w_ammo[2],
                  ST_AMMO2X,
                  ST_AMMO2Y,
                  shortnum,
                  &plyr->ammo[2],
                  &st_statusbaron,
                  ST_AMMO2WIDTH);

    STlib_initNum(&w_ammo[3],
                  ST_AMMO3X,
                  ST_AMMO3Y,
                  shortnum,
                  &plyr->ammo[3],
                  &st_statusbaron,
                  ST_AMMO3WIDTH);

    // max ammo count (all four kinds)
    STlib_initNum(&w_maxammo[0],
                  ST_MAXAMMO0X,
                  ST_MAXAMMO0Y,
                  shortnum,
                  &plyr->maxammo[0],
                  &st_statusbaron,
                  ST_MAXAMMO0WIDTH);

    STlib_initNum(&w_maxammo[1],
                  ST_MAXAMMO1X,
                  ST_MAXAMMO1Y,
                  shortnum,
                  &plyr->maxammo[1],
                  &st_statusbaron,
                  ST_MAXAMMO1WIDTH);

    STlib_initNum(&w_maxammo[2],
                  ST_MAXAMMO2X,
                  ST_MAXAMMO2Y,
                  shortnum,
                  &plyr->maxammo[2],
                  &st_statusbaron,
                  ST_MAXAMMO2WIDTH);

    STlib_initNum(&w_maxammo[3],
                  ST_MAXAMMO3X,
                  ST_MAXAMMO3Y,
                  shortnum,
                  &plyr->maxammo[3],
                  &st_statusbaron,
                  ST_MAXAMMO3WIDTH);

}

static boolean	st_stopped = true;


void ST_Start (void)
{

    if (!st_stopped)
        ST_Stop();

    ST_initData();
    ST_createWidgets();
    st_stopped = false;

}

void ST_Stop (void)
{
    if (st_stopped)
        return;

    I_SetPalette (W_CacheLumpNum (lu_palette, PU_CACHE));

    st_stopped = true;
}

void ST_Init (void)
{
    veryfirsttime = 0;
    ST_loadData();
    screens[4] = (byte *) Z_Malloc(ST_WIDTH*ST_HEIGHT, PU_STATIC, 0);
}
